package com.guochu.utils.redis;

import com.guochu.common.constant.CommonConst;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 */
@Service
public class RedisUtil {

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 批量删除对应的value
     *
     * @param keys 键值，可多个参数
     */
    public void remove(String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key 键值
     */
    public void remove(String key) {
        // 判断redis缓存中是否有value
        if (exists(key)) {
            redisTemplate.delete(CommonConst.CACHE_PREFIX + key);
        }
    }

    /**
     * 设置key/value值。
     *
     * @param:key
     * @param:val
     */
    public void set(String key, Object val) {
        redisTemplate.opsForValue().set(CommonConst.CACHE_PREFIX + key, val);
    }

    /**
     * 设置key/value值，并且设置超时时间。
     *
     * @param:key
     * @param:val
     * @param:time 时间
     * @param:unit 时间单位，例如  TimeUnit.SECONDS
     */
    public void set(String key, Object val, int time, TimeUnit unit) {
        redisTemplate.opsForValue().set(CommonConst.CACHE_PREFIX + key, val, time, unit);
    }

    /**
     * 判断缓存中是否有对应的value
     * <p>
     * 缓存前缀 CommonConst.CACHE_PREFIX
     *
     * @param key
     * @return
     */
    public boolean exists(String key) {
        return redisTemplate.hasKey(CommonConst.CACHE_PREFIX + key);
    }

    /**
     * 设置过期时间。
     *
     * @param:key
     * @param:expireTime
     * @param:unit
     */
    public boolean setExpire(String key, long expireTime, TimeUnit unit) {
        return redisTemplate.expire(CommonConst.CACHE_PREFIX + key, expireTime, unit);
    }

    /**
     * 获取key键对应的值。
     *
     * @param:key
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(CommonConst.CACHE_PREFIX + key);
    }

    /**
     * 同时设置多个key/value
     * 设置map集合到redis
     *
     * @param:map
     */
    public void multiSet(Map<String, Object> map) {
        Map<String, Object> newMap = new HashMap<String, Object>();
        for (String key : map.keySet()) {
            newMap.put(CommonConst.CACHE_PREFIX + key, map.get(key));
        }

        redisTemplate.opsForValue().multiSet(newMap);
    }

    /**
     * 队列左侧添加一个元素
     *
     * @param:key
     * @param:value
     */
    public void leftPush(String key, String value) {
        redisTemplate.opsForList().leftPush(CommonConst.CACHE_PREFIX + key, value);
    }

    /**
     * 队列查询
     *
     * @param:key
     * @param:start
     * @param:end
     */
    public List<Object> range(String key, int start, int end) {
        return redisTemplate.opsForList().range(CommonConst.CACHE_PREFIX + key, start, end);
    }

    /**
     * 移除并获取列表最后一个元素
     *
     * @param key
     * @return 删除的元素
     */
    public Object rightPop(String key) {
        return redisTemplate.opsForList().rightPop(CommonConst.CACHE_PREFIX + key);
    }

    /**
     * 设置hash值
     *
     * @param:key
     * @param:map
     */
    public void setHashMap(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(CommonConst.CACHE_PREFIX + key, map);
    }

    /**
     * 获取hash的hash结果。
     *
     * @param:key
     */
    public Map<String, Object> getHashMap(String key) {
        return redisTemplate.opsForHash().entries(CommonConst.CACHE_PREFIX + key);
    }

    /**
     * 设置hash的某个属性的值，存在则修改，不存在则新增
     *
     * @param:key
     * @param:prop
     */
    public void setHashValue(String key, String prop, Object value) {
        redisTemplate.opsForHash().put(CommonConst.CACHE_PREFIX + key, prop, value);
    }

    /**
     * 获取hash的某个属性的值
     *
     * @param:key
     * @param:prop
     */
    public Object getHashValue(String key, String prop) {
        Object o = redisTemplate.opsForHash().get(CommonConst.CACHE_PREFIX + key, prop);
        return o;
    }

    /**
     * 判断hash是否存在指定的键
     *
     * @param:key
     * @param:prop
     */
    public boolean hasHashKey(String key, String prop) {
        return redisTemplate.opsForHash().hasKey(CommonConst.CACHE_PREFIX + key, prop);
    }

    /**
     * 删除hash中指定的键
     *
     * @param key
     * @param prop
     */
    public void removeHashKey(String key, String... prop) {
        redisTemplate.opsForHash().delete(CommonConst.CACHE_PREFIX + key, prop);
    }

    /**
     * 获取hash所有属性和值
     *
     * @param:key
     */
    public Map getHashAll(String key) {
        Map map = new HashMap();
        map.put("keys", redisTemplate.opsForHash().keys(CommonConst.CACHE_PREFIX + key));
        map.put("values", redisTemplate.opsForHash().values(CommonConst.CACHE_PREFIX + key));
        return map;
    }
}
